#include "Encoder.h"

volatile uint32_t Encoder_Capture1;
volatile uint32_t Encoder_Capture2;

int32_t gLoadValue1;
volatile int32_t gCaptureCnt1;
volatile bool gSynced = true;

int32_t gLoadValue2;
volatile int32_t gCaptureCnt2;
volatile bool gSynced2 = true;

void Encoder_Init(void) {
  // IO 口模拟
  NVIC_EnableIRQ(Encoder_Capture_INT_IRQN);

  /**
   * 输入捕获通道
   **/
  //   gLoadValue = DL_TimerG_getLoadValue(Encoder_INST);
  //   gLoadValue2 = DL_TimerG_getLoadValue(Encoder2_INST);
  //   NVIC_EnableIRQ(Encoder_INST_INT_IRQN);
  //   NVIC_EnableIRQ(Encoder2_INST_INT_IRQN);
  //   DL_TimerG_startCounter(Encoder_INST);
  //   DL_TimerG_startCounter(Encoder2_INST);
}

float Encoder_Get_Freq(void) { return gCaptureCnt1; }
float Encoder_Get_Freq2(void) { return gCaptureCnt2; }

/**
 *   捕获通道
 **/
// void GROUP1_IRQHandler(void) {
//   // 获取中断信号
//   //  Encoder_Capture1 =
//   DL_GPIO_getEnabledInterruptStatus(Encoder_Capture_PORT,
//   //  Encoder_Capture_Capture1_A_PIN | Encoder_Capture_Capture1_B_PIN);
//   Encoder_Capture2 = DL_GPIO_getEnabledInterruptStatus(
//       Encoder_Capture_PORT,
//       Encoder_Capture_Capture2_A_PIN | Encoder_Capture_Capture2_B_PIN);

//   //-------------------------- ENCODER_CAPTURE1 ---------------------------
//   // 如果是GPIO_EncoderA_PIN_0_PIN产生的中断
//   //  if((Encoder_Capture1 & Encoder_Capture_Capture1_A_PIN) ==
//   //  Encoder_Capture_Capture1_A_PIN)
//   //  {
//   //      //Pin0上升沿，看Pin1的电平，为低电平则判断为反转，高电平判断为正转
//   //
//   if(!DL_GPIO_readPins(Encoder_Capture_PORT,Encoder_Capture_Capture1_B_PIN))//P1为低电平
//   //      {
//   //          gCaptureCnt1--;
//   //      }
//   //      else//P1为高电平
//   //      {
//   //          gCaptureCnt1++;
//   //      }
//   //  }

//   // else if((Encoder_Capture1 & Encoder_Capture_Capture1_B_PIN) ==
//   // Encoder_Capture_Capture1_B_PIN)
//   // {
//   //     //Pin1上升沿
//   //
//   if(!DL_GPIO_readPins(Encoder_Capture_PORT,Encoder_Capture_Capture1_A_PIN))//P0为低电平
//   //     {
//   //         gCaptureCnt1++;
//   //     }
//   //     else//P1为高电平
//   //     {
//   //         gCaptureCnt1--;
//   //     }
//   // }

//   // -------------------------- ENCODER_CAPTURE2 ---------------------------
//   if ((Encoder_Capture2 & Encoder_Capture_Capture2_A_PIN) ==
//       Encoder_Capture_Capture2_A_PIN) {
//     if (!DL_GPIO_readPins(Encoder_Capture_PORT,
//                           Encoder_Capture_Capture2_B_PIN)) // P1为低电平
//     {
//       gCaptureCnt2--;
//     } else // P1为高电平
//     {
//       gCaptureCnt2++;
//     }
//   }

//   else if ((Encoder_Capture2 & Encoder_Capture_Capture2_B_PIN) ==
//            Encoder_Capture_Capture2_B_PIN) {

//     if (!DL_GPIO_readPins(Encoder_Capture_PORT,
//                           Encoder_Capture_Capture2_A_PIN)) // P0为低电平
//     {
//       gCaptureCnt2++;
//     } else {
//       gCaptureCnt2--;
//     }
//   }

//   // 最后清除中断标志位
//   DL_GPIO_clearInterruptStatus(
//       Encoder_Capture_PORT,
//       Encoder_Capture_Capture1_A_PIN | Encoder_Capture_Capture1_B_PIN |
//           Encoder_Capture_Capture2_A_PIN | Encoder_Capture_Capture2_B_PIN);
// }

/**
 *   捕获通道获取频率
 **/

// void DL_TIMERG_IIDX_CC0_DN_Handle() {
//   if (!DL_GPIO_readPins(GPIO_Encoder_Capture_PORT_C0_PORT,
//                         GPIO_Encoder_Capture_PORT_C0_PIN))
//   {
//     gCaptureCnt1--;
//   } else // P1为高电平
//   {
//     gCaptureCnt1++;
//   }
// }

// void DL_TIMERG_IIDX_CC1_DN_Handle() {
//   if (!DL_GPIO_readPins(GPIO_Encoder_Capture_PORT_C1_PORT,
//                         GPIO_Encoder_Capture_PORT_C1_PIN))
//   {
//     gCaptureCnt1++;
//   } else {
//     gCaptureCnt1--;
//   }
// }

// void Encoder_INST_IRQHandler(void) {
//   switch (DL_TimerG_getPendingInterrupt(Encoder_Capture_PORT_INST)) {
//   case DL_TIMERG_IIDX_CC0_DN:
//     DL_TIMERG_IIDX_CC0_DN_Handle();
//     break;
//   case DL_TIMERG_IIDX_CC1_DN:
//     DL_TIMERG_IIDX_CC1_DN_Handle();
//     break;
//   default:
//     break;
//   }
// }
uint8_t x, y, z, sum, x2, y2, z2, sum2;
void Count_Capture(void) {
  if (DL_GPIO_getEnabledInterruptStatus(Encoder_Capture_PORT,
                                        Encoder_Capture_Capture1_A_PIN)) {
    x = 1; // A中断，则x=1;B中断，则x=0;

    // 中断发生时，A相高电平，y=1；反之y=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture1_A_PIN))
      y = 1;
    else
      y = 0;
    // 中断发生时，B相高电平，z=1；反之z=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture1_B_PIN))
      z = 1;
    else
      z = 0;

    sum = x + y + z; // 求和判断转动方向，偶数正转，奇数反转
    if (sum == 0 || sum == 2)
      gCaptureCnt1++;
    else
      gCaptureCnt1--;

    DL_GPIO_clearInterruptStatus(Encoder_Capture_PORT,
                                 Encoder_Capture_Capture1_A_PIN);
  }

  else if (DL_GPIO_getEnabledInterruptStatus(Encoder_Capture_PORT,
                                        Encoder_Capture_Capture1_B_PIN)) {
    x = 0; // A中断，则x=1;B中断，则x=0;
    // 中断发生时，A相高电平，y=1；反之y=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture1_A_PIN))
      y = 1;
    else
      y = 0;
    // 中断发生时，B相高电平，z=1；反之z=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture1_B_PIN))
      z = 1;
    else
      z = 0;

    sum = x + y + z; // 求和判断转动方向，偶数正转，奇数反转
    if (sum == 0 || sum == 2)
      gCaptureCnt1++;
    else
      gCaptureCnt1--;

    DL_GPIO_clearInterruptStatus(Encoder_Capture_PORT,
                                 Encoder_Capture_Capture1_B_PIN);
  }

  // ----------------- ENCODER2 ----------------
  if (DL_GPIO_getEnabledInterruptStatus(Encoder_Capture_PORT,
                                        Encoder_Capture_Capture2_A_PIN)) {
    x2 = 1; // A中断，则x=1;B中断，则x=0;

    // 中断发生时，A相高电平，y=1；反之y=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture2_A_PIN))
      y2 = 1;
    else
      y2 = 0;
    // 中断发生时，B相高电平，z=1；反之z=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture2_B_PIN))
      z2 = 1;
    else
      z2 = 0;

    sum2 = x2 + y2 + z2; // 求和判断转动方向，偶数正转，奇数反转
    if (sum2 == 0 || sum2 == 2)
      gCaptureCnt2++;
    else
      gCaptureCnt2--;

    DL_GPIO_clearInterruptStatus(Encoder_Capture_PORT,
                                 Encoder_Capture_Capture2_A_PIN);
  }

  else if (DL_GPIO_getEnabledInterruptStatus(Encoder_Capture_PORT,
                                        Encoder_Capture_Capture2_B_PIN)) {
    x2 = 0; // A中断，则x=1;B中断，则x=0;
    // 中断发生时，A相高电平，y=1；反之y=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture2_A_PIN))
      y2 = 1;
    else
      y2 = 0;
    // 中断发生时，B相高电平，z=1；反之z=0;
    if (DL_GPIO_readPins(Encoder_Capture_PORT, Encoder_Capture_Capture2_B_PIN))
      z2 = 1;
    else
      z2 = 0;

    sum2 = x2 + y2 + z2; // 求和判断转动方向，偶数正转，奇数反转
    if (sum2 == 0 || sum2 == 2)
      gCaptureCnt2++;
    else
      gCaptureCnt2--;

    DL_GPIO_clearInterruptStatus(Encoder_Capture_PORT,
                                 Encoder_Capture_Capture2_B_PIN);
  }
}

void GROUP1_IRQHandler(void) {
  switch (DL_Interrupt_getPendingGroup(DL_INTERRUPT_GROUP_1)) {
  case Encoder_Capture_INT_IIDX:
    Count_Capture();
    break;
  }
}
